"""
视频号模块，用于管理视频号直播相关功能
"""
from PyQt5.QtWidgets import (
    QWidget, QVBoxLayout, QHBoxLayout, QGroupBox, QLabel, 
    QLineEdit, QComboBox, QCheckBox, QPushButton, QTextEdit,
    QSlider, QTableWidget, QTableWidgetItem, QHeaderView,
    QSpinBox, QMessageBox
)
from PyQt5.QtCore import Qt, pyqtSignal, QThread, QTimer, QMetaObject, Q_ARG, pyqtSlot
from PyQt5.QtGui import QTextCursor
import asyncio
import sys
import threading
import time
import requests
import json

from app.ui.components.styled_button import StyledButton
from app.ui.components.styled_label import StyledLabel
from app.utils.logger import Logger
from app.ui.components.toast import show_toast, Toast
from app.wx_live import WXLiveConfig, WXLiveEventListener, WXLiveService

# 常量定义
CHANNEL_LIVE_URL = "https://channels.weixin.qq.com/platform/live/liveBuild"
DEFAULT_TIMEOUT = 30000  # 30秒超时
MAX_RETRIES = 3  # 最大重试次数

# 导入playwright相关依赖
try:
    from playwright.async_api import async_playwright, TimeoutError as PlaywrightTimeoutError
    PLAYWRIGHT_AVAILABLE = True
except ImportError:
    PLAYWRIGHT_AVAILABLE = False

# 直播状态检查线程
class LiveStatusThread(QThread):
    """
    直播状态检查线程，用于在后台获取直播状态
    """
    
    # 定义信号
    status_updated = pyqtSignal(dict)  # 状态信息字典
    
    def __init__(self, parent=None):
        """
        初始化状态检查线程
        
        @param parent: 父对象
        """
        super().__init__(parent)
        self.logger = Logger.get_logger("live_status_thread")
    
    def run(self):
        """
        线程运行方法
        """
        try:
            # 在新线程中创建一个事件循环
            loop = asyncio.new_event_loop()
            asyncio.set_event_loop(loop)
            
            # 运行检查直播状态的异步方法
            result = loop.run_until_complete(self.check_live_status())
            
            # 检查是否成功
            if result.get("success", False):
                self.logger.debug(f"直播状态检查成功: {result.get('live_status', '未知')}, 观众: {result.get('viewers', 0)}")
            else:
                self.logger.error(f"直播状态检查失败: {result.get('error', '未知错误')}")
            
            # 发送状态更新信号
            self.status_updated.emit(result)
        except Exception as e:
            self.logger.error(f"在状态检查线程中发生错误: {str(e)}")
            # 发送错误信息
            self.status_updated.emit({
                "success": False,
                "error": str(e)
            })
        finally:
            # 确保线程标记为完成
            self.logger.debug("直播状态检查线程已完成")
    
    async def check_live_status(self):
        """
        异步方法：检查直播状态，包含重试机制
        
        @return: 状态信息字典
        """
        retry_count = 0
        last_error = None
        
        while retry_count < MAX_RETRIES:
            try:
                # 只在第一次尝试或失败重试时使用INFO级别记录
                if retry_count == 0:
                    self.logger.debug(f"正在检查直播状态... (尝试 {retry_count + 1}/{MAX_RETRIES})")
                else:
                    self.logger.info(f"正在检查直播状态... (尝试 {retry_count + 1}/{MAX_RETRIES})")
                
                async with async_playwright() as p:
                    # 启动浏览器（使用headless模式，不显示界面）
                    browser = await p.chromium.launch(headless=True)
                    
                    try:
                        # 创建新的上下文和页面
                        context = await browser.new_context()
                        page = await context.new_page()
                        
                        # 导航到视频号直播管理页面，添加超时设置
                        await page.goto(CHANNEL_LIVE_URL, timeout=DEFAULT_TIMEOUT)
                        
                        # 等待页面加载
                        await page.wait_for_load_state("networkidle", timeout=DEFAULT_TIMEOUT)
                        
                        # 检查是否需要登录（使用新的定位器API）
                        login_required = await page.get_by_text("登录").is_visible()
                        if login_required:
                            return {
                                "success": True,
                                "live_status": "需要登录",
                                "viewers": 0,
                                "message": "请先在浏览器中登录微信视频号后台"
                            }
                        
                        # 尝试获取直播状态信息
                        try:
                            # 查找直播状态元素（使用新的定位器API）
                            if await page.get_by_text("直播中").is_visible():
                                live_status = "直播中"
                            elif await page.get_by_text("未开播").is_visible():
                                live_status = "未开播"
                            else:
                                live_status = "未知"
                            
                            # 尝试获取观众数量
                            viewers = 0
                            try:
                                # 使用兼容的API替代first_or_none方法
                                viewers_locator = page.get_by_text("当前观众")
                                # 检查元素是否存在
                                if await viewers_locator.count() > 0:
                                    # 获取第一个匹配元素
                                    viewers_el = viewers_locator.nth(0)
                                    # 提取观众数量
                                    viewers_text = await viewers_el.inner_text()
                                    # 提取数字
                                    import re
                                    matches = re.findall(r'\d+', viewers_text)
                                    if matches:
                                        viewers = int(matches[0])
                            except Exception as e:
                                self.logger.warning(f"获取观众数量失败: {str(e)}")
                                # 继续执行，使用默认的观众数量0
                            
                            return {
                                "success": True,
                                "live_status": live_status,
                                "viewers": viewers
                            }
                        except Exception as e:
                            self.logger.error(f"解析直播状态时出错: {str(e)}")
                            return {
                                "success": True,
                                "live_status": "未知",
                                "viewers": 0,
                                "message": "无法解析状态信息"
                            }
                    finally:
                        # 关闭浏览器
                        await browser.close()
            except PlaywrightTimeoutError as e:
                # 超时错误，可以重试
                retry_count += 1
                last_error = f"页面加载超时: {str(e)}"
                self.logger.warning(f"检查直播状态超时，将重试 ({retry_count}/{MAX_RETRIES}): {last_error}")
                
                # 短暂等待后重试
                await asyncio.sleep(2)
            except Exception as e:
                # 其他错误，记录后返回
                self.logger.error(f"检查直播状态时发生错误: {str(e)}")
                return {
                    "success": False,
                    "error": str(e)
                }
        
        # 达到最大重试次数后返回错误
        self.logger.error(f"检查直播状态失败，达到最大重试次数: {last_error}")
        return {
            "success": False,
            "error": f"达到最大重试次数 ({MAX_RETRIES})，最后一次错误: {last_error}"
        }

class ChannelModule(QWidget):
    """
    视频号模块，用于管理视频号直播相关功能
    """
    
    # 定义信号
    channel_config_updated = pyqtSignal(str, object)
    
    # 添加更新UI的信号
    update_ui_signal = pyqtSignal(str, str, int)
    
    def __init__(self, parent=None):
        """
        初始化视频号模块
        """
        super().__init__(parent)
        
        # 获取日志记录器
        self.logger = Logger.get_logger("channel_module")
        self.setObjectName("channelModule")
        
        # 初始化状态检查参数
        self.last_refresh_time = 0  # 上次刷新时间戳
        self.min_refresh_interval = 2  # 最小刷新间隔（秒）
        self.status_thread = None  # 状态检查线程引用
        
        # 初始化UI
        self._init_ui()
        
        # 初始化微信直播相关组件
        self.wx_config = WXLiveConfig()
        self.wx_service = WXLiveService(self.wx_config)
        self.wx_listener = None
        
        # 添加事件处理器
        self.wx_service.add_observer(self._on_wx_live_event)
        
        # 连接信号到槽
        self.update_ui_signal.connect(self._update_log_and_toast)
        
        # 注释掉自动检测定时器，只保留手动刷新功能
        # self.status_timer = QTimer(self)
        # self.status_timer.timeout.connect(self._on_refresh_clicked)
        # self.status_timer.start(30000)  # 30000毫秒 = 30秒
        # self.logger.info("已启动自动检测直播状态功能，间隔：30秒")
        self.logger.info("已禁用自动检测直播状态功能，使用WebSocket实时状态更新")
    
    def _init_ui(self):
        """
        初始化UI
        """
        # 创建主布局
        main_layout = QVBoxLayout(self)
        main_layout.setContentsMargins(10, 10, 10, 10)
        main_layout.setSpacing(10)
        
        # 创建功能组
        self._create_control_group(main_layout)
        
        # 创建置顶话术组
        self._create_pinned_speech_group(main_layout)
        
        # 创建日志组
        self._create_log_group(main_layout)
    
    def _create_control_group(self, parent_layout):
        """
        创建控制功能组
        
        @param parent_layout: 父布局
        """
        # 创建控制组
        control_group = QGroupBox("直播控制")
        control_layout = QHBoxLayout(control_group)  # 改为水平布局
        control_layout.setContentsMargins(10, 15, 10, 15)
        control_layout.setSpacing(10)
        
        # 创建状态部分
        status_part = QHBoxLayout()
        status_part.setSpacing(5)
        
        # 创建状态标签
        status_label = QLabel("直播状态:")
        status_label.setFixedWidth(60)
        self.status_label = status_label
        self.status_value = QLabel("未知")
        self.status_value.setStyleSheet("color: #999;")
        
        # 创建观众数标签
        viewers_label = QLabel("观众:")
        viewers_label.setFixedWidth(40)
        self.viewers_value = QLabel("0")
        
        # 添加到状态部分
        status_part.addWidget(status_label)
        status_part.addWidget(self.status_value)
        status_part.addSpacing(20)
        status_part.addWidget(viewers_label)
        status_part.addWidget(self.viewers_value)
        
        # 创建按钮部分
        button_part = QHBoxLayout()
        button_part.setSpacing(10)
        
        # 创建打开直播后台按钮
        open_backend_button = QPushButton("打开直播后台")
        open_backend_button.setMinimumHeight(30)
        open_backend_button.setStyleSheet("""
            QPushButton {
                background-color: #1890ff;
                color: white;
                border: none;
                border-radius: 4px;
                padding: 5px 15px;
            }
            QPushButton:hover {
                background-color: #40a9ff;
            }
            QPushButton:pressed {
                background-color: #096dd9;
            }
        """)
        open_backend_button.clicked.connect(self._on_open_backend_clicked)
        self.open_button = open_backend_button
        
        # 创建刷新状态按钮
        refresh_button = QPushButton("刷新直播状态")
        refresh_button.setMinimumHeight(30)
        refresh_button.setStyleSheet("""
            QPushButton {
                background-color: #f5f5f5;
                color: #333;
                border: 1px solid #d9d9d9;
                border-radius: 4px;
                padding: 5px 15px;
            }
            QPushButton:hover {
                background-color: #e6f7ff;
                border-color: #1890ff;
            }
            QPushButton:pressed {
                background-color: #d9d9d9;
            }
        """)
        refresh_button.clicked.connect(self._on_refresh_clicked)
        
        # 添加按钮到布局
        button_part.addWidget(open_backend_button)
        button_part.addWidget(refresh_button)
        
        # 组合所有部分到主布局
        control_layout.addLayout(status_part)
        control_layout.addStretch(1)
        control_layout.addLayout(button_part)
        
        # 添加到父布局
        parent_layout.addWidget(control_group)
    
    def _create_pinned_speech_group(self, parent_layout):
        """
        创建置顶话术组
        
        @param parent_layout: 父布局
        """
        # 创建置顶话术组
        pinned_group = QGroupBox("置顶话术")
        pinned_layout = QHBoxLayout(pinned_group)  # 改为水平布局
        pinned_layout.setContentsMargins(10, 15, 10, 15)
        pinned_layout.setSpacing(10)
        
        # 启用置顶话术复选框
        self.pinned_enabled = QCheckBox("启用置顶话术")
        self.pinned_enabled.setChecked(False)
        self.pinned_enabled.stateChanged.connect(self._on_pinned_enabled_changed)
        pinned_layout.addWidget(self.pinned_enabled)
        
        # 关键词标签和输入框
        keyword_label = QLabel("关键词:")
        keyword_label.setFixedWidth(50)
        
        self.keyword_input = QLineEdit()
        self.keyword_input.setMinimumHeight(28)
        self.keyword_input.setPlaceholderText("输入关键词")
        self.keyword_input.setStyleSheet("""
            QLineEdit {
                border: 1px solid #d9d9d9;
                border-radius: 4px;
                padding: 2px 8px;
            }
            QLineEdit:focus {
                border-color: #40a9ff;
                box-shadow: 0 0 0 2px rgba(24, 144, 255, 0.2);
            }
        """)
        self.keyword_input.textChanged.connect(self._on_keyword_changed)
        
        pinned_layout.addWidget(keyword_label)
        pinned_layout.addWidget(self.keyword_input)
        
        # 频率标签和输入框
        frequency_label = QLabel("频率:")
        frequency_label.setFixedWidth(40)
        frequency_label.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
        
        self.frequency_spinbox = QSpinBox()
        self.frequency_spinbox.setMinimum(1)
        self.frequency_spinbox.setMaximum(100)
        self.frequency_spinbox.setValue(5)
        self.frequency_spinbox.setSuffix(" 分钟")
        self.frequency_spinbox.setMinimumHeight(28)
        self.frequency_spinbox.setFixedWidth(80)
        self.frequency_spinbox.setStyleSheet("""
            QSpinBox {
                border: 1px solid #d9d9d9;
                border-radius: 4px;
                padding: 2px 8px;
            }
            QSpinBox:focus {
                border-color: #40a9ff;
            }
        """)
        self.frequency_spinbox.valueChanged.connect(self._on_frequency_changed)
        
        pinned_layout.addWidget(frequency_label)
        pinned_layout.addWidget(self.frequency_spinbox)
        pinned_layout.addStretch(1)
        
        # 添加到父布局
        parent_layout.addWidget(pinned_group)
    
    def _create_log_group(self, parent_layout):
        """
        创建日志组
        
        @param parent_layout: 父布局
        """
        # 创建日志组
        log_group = QGroupBox("视频号日志")
        log_layout = QVBoxLayout(log_group)
        log_layout.setContentsMargins(10, 15, 10, 15)
        log_layout.setSpacing(8)
        
        # 创建日志文本框
        self.log_text = QTextEdit()
        self.log_text.setReadOnly(True)  # 设置为只读
        self.log_text.setMinimumHeight(120)  # 设置最小高度
        self.log_text.setStyleSheet("""
            QTextEdit {
                border: 1px solid #d9d9d9;
                border-radius: 4px;
                background-color: #f9f9f9;
                font-family: "Microsoft YaHei", Arial, sans-serif;
                font-size: 12px;
                padding: 4px;
            }
        """)
        
        # 添加到布局
        log_layout.addWidget(self.log_text)
        
        # 创建按钮行
        button_row = QHBoxLayout()
        button_row.setContentsMargins(0, 0, 0, 0)
        
        # 创建清空日志按钮
        clear_log_button = QPushButton("清空日志")
        clear_log_button.setMinimumHeight(26)
        clear_log_button.setFixedWidth(80)
        clear_log_button.setStyleSheet("""
            QPushButton {
                background-color: #f5f5f5;
                color: #333;
                border: 1px solid #d9d9d9;
                border-radius: 4px;
            }
            QPushButton:hover {
                background-color: #e6e6e6;
            }
            QPushButton:pressed {
                background-color: #d9d9d9;
            }
        """)
        clear_log_button.clicked.connect(self._on_clear_log_clicked)
        
        # 添加按钮到布局
        button_row.addStretch(1)  # 添加弹性空间
        button_row.addWidget(clear_log_button)
        
        # 添加到日志布局
        log_layout.addLayout(button_row)
        
        # 添加到父布局
        parent_layout.addWidget(log_group)
    
    def add_log(self, message):
        """
        添加日志
        
        @param message: 日志消息
        """
        # 获取当前时间
        now = time.strftime("%H:%M:%S", time.localtime())
        log_msg = f"[{now}] {message}"
        
        # 添加到日志文本框
        self.log_text.append(log_msg)
        
        # 滚动到底部
        cursor = self.log_text.textCursor()
        cursor.movePosition(QTextCursor.End)
        self.log_text.setTextCursor(cursor)
    
    # 槽函数
    def _on_open_backend_clicked(self):
        """
        处理打开直播后台按钮点击事件
        """
        try:
            # 检查Playwright是否可用
            if not PLAYWRIGHT_AVAILABLE:
                error_msg = "无法打开直播后台: playwright模块未正确安装"
                self.add_log(f"错误: {error_msg}")
                self.logger.error(error_msg)
                
                # 显示错误提示
                self.add_log("应用程序安装不完整，请联系技术支持")
                show_toast(self, "无法打开直播后台，应用程序安装不完整", 3000, Toast.ERROR)
                return
            
            # 如果已经有一个监听器在运行，先停止它
            if self.wx_listener and self.wx_listener.is_alive():
                self.add_log("正在停止当前监听...")
                try:
                    # 尝试调用stop方法
                    if hasattr(self.wx_listener, 'stop'):
                        self.wx_listener.stop()
                    # 等待最多2秒
                    self.wx_listener.join(2.0)
                except Exception as e:
                    self.logger.warning(f"停止监听器时出错: {str(e)}")
                
                # 如果线程仍在运行，创建新的监听器实例
                if self.wx_listener.is_alive():
                    self.add_log("无法正常停止旧监听器，创建新实例")
                    self.wx_listener = None
                    
            # 创建并启动新的监听器
            self.wx_listener = WXLiveEventListener(self.wx_config, self.wx_service)
            self.wx_listener.start()
            
            # 启用保存配置按钮 - 确保这一步不会被错误中断
            try:
                # 更新按钮状态
                if hasattr(self, 'open_button'):
                    self.open_button.setEnabled(False)
                    QTimer.singleShot(3000, lambda: self.open_button.setEnabled(True))
                
                if hasattr(self, 'status_label'):
                    self.status_label.setText("直播监听中...")
            except Exception as e:
                self.logger.warning(f"更新UI状态时出错: {str(e)}")
            
            # 记录日志
            self.add_log("已打开直播后台，开始监听...")
        except FileNotFoundError as e:
            error_msg = f"打开直播后台失败: {str(e)}"
            self.add_log(error_msg)
            self.logger.error(error_msg)
            
            # 本地浏览器文件缺失的提示
            detailed_msg = "应用程序所需的浏览器文件丢失或损坏。请尝试重新安装应用，或联系技术支持。"
            self.add_log(detailed_msg)
            show_toast(self, "浏览器文件丢失", 3000, Toast.ERROR)
        except Exception as e:
            error_msg = f"打开直播后台失败: {str(e)}"
            self.add_log(error_msg)
            self.logger.error(error_msg)
            
            # 其他错误提示
            detailed_msg = "启动浏览器时发生未知错误，请尝试重新安装应用。"
            self.add_log(detailed_msg)
            show_toast(self, "启动浏览器失败", 3000, Toast.ERROR)
            
            # 即使出错，如果监听器已经启动，也启用保存按钮
            if self.wx_listener and self.wx_listener.is_alive():
                self.add_log("监听器已启动，继续监听中...")
    
    def _on_refresh_clicked(self):
        """
        处理刷新按钮点击事件
        """
        # 检查刷新间隔
        current_time = time.time()
        if current_time - self.last_refresh_time < self.min_refresh_interval:
            self.logger.debug(f"刷新间隔过短，跳过本次刷新 (间隔: {current_time - self.last_refresh_time:.2f}秒)")
            return
        
        # 检查是否有正在运行的检查线程
        if self.status_thread and self.status_thread.isRunning():
            self.logger.debug("上一次检查尚未完成，跳过本次刷新")
            return
        
        # 更新最后刷新时间
        self.last_refresh_time = current_time
        
        # 静默刷新，不再每次都添加日志
        self.logger.debug("开始刷新视频号直播状态...")
        
        if not PLAYWRIGHT_AVAILABLE:
            error_msg = "无法刷新状态: playwright模块未安装"
            self.add_log(f"错误: {error_msg}")
            self.logger.error(error_msg)
            
            # 显示简短提示，不再显示详细的安装指南（避免重复）
            show_toast(self, "无法刷新状态: 缺少playwright模块", 3000, Toast.ERROR)
            return
        
        try:
            # 启动状态检查线程
            self.status_thread = LiveStatusThread(self)
            self.status_thread.status_updated.connect(self._on_status_updated)
            self.status_thread.start()
        except Exception as e:
            error_msg = f"刷新视频号直播状态失败: {str(e)}"
            self.add_log(f"错误: {error_msg}")
            self.logger.error(error_msg)
            show_toast(self, "刷新状态失败", 3000, Toast.ERROR)
    
    def _on_status_updated(self, result):
        """
        处理状态更新
        
        @param result: 状态结果字典
        """
        if not result.get("success", False):
            error = result.get("error", "未知错误")
            self.add_log(f"刷新直播状态失败: {error}")
            self.logger.error(f"刷新直播状态失败: {error}")
            show_toast(self, f"刷新失败: {error}", 3000, Toast.ERROR)
            return
            
        # 更新直播状态
        live_status = result.get("live_status", "未知")
        viewers = result.get("viewers", 0)
        
        # 获取当前显示的状态
        current_status = self.status_value.text()
        current_viewers = self.viewers_value.text()
        
        # 只有在状态发生变化时才记录日志
        status_changed = (current_status != live_status) or (current_viewers != str(viewers))
        
        # 更新UI显示
        self.update_status_display(live_status, viewers)
        
        if "message" in result:
            # 显示重要消息，如需要登录等
            self.add_log(result["message"])
            self.logger.info(result["message"])
        
        # 只有在状态变化时才添加日志
        if status_changed:
            self.add_log(f"直播状态已更新: {live_status}, 观众数: {viewers}")
            self.logger.info(f"直播状态已变更: {current_status} → {live_status}, 观众: {current_viewers} → {viewers}")
    
    def update_status_display(self, live_status, viewers):
        """
        更新状态显示
        
        @param live_status: 直播状态
        @param viewers: 观众数
        """
        self.status_value.setText(live_status)
        
        # 设置状态颜色
        if live_status == "直播中":
            self.status_value.setStyleSheet("color: green; font-weight: bold;")
        elif live_status == "未开播":
            self.status_value.setStyleSheet("color: #FF9800; font-weight: bold;")
        elif live_status == "需要登录":
            self.status_value.setStyleSheet("color: blue; font-weight: bold;")
        else:
            self.status_value.setStyleSheet("color: gray;")
            
        # 更新观众数
        self.viewers_value.setText(str(viewers))
    
    def _on_pinned_enabled_changed(self, state):
        """
        处理置顶话术启用状态改变事件
        
        @param state: 复选框状态
        """
        enabled = (state == Qt.Checked)
        self.add_log(f"置顶话术功能已{'启用' if enabled else '禁用'}")
        self.channel_config_updated.emit("pinned.enabled", enabled)
    
    def _on_keyword_changed(self, text):
        """
        处理关键词选择改变事件
        
        @param text: 选中的文本
        """
        if text:
            self.add_log(f"已设置置顶话术关键词: {text}")
            self.channel_config_updated.emit("pinned.keyword", text)
    
    def _on_frequency_changed(self, value):
        """
        处理频率改变事件
        
        @param value: 新的频率值
        """
        self.add_log(f"置顶话术频率已设置为: {value}分钟")
        self.channel_config_updated.emit("pinned.frequency", value)
    
    def _on_clear_log_clicked(self):
        """
        处理清空日志按钮点击事件
        """
        self.log_text.clear()
        self.add_log("日志已清空")
    
    def _on_wx_live_event(self, event_type, data):
        """
        处理微信直播事件
        
        @param event_type: 事件类型
        @param data: 事件数据
        """
        try:
            if event_type == "status_update":
                # 更新状态显示
                # 优先使用live_status，如果不存在则使用status
                live_status = data.get("live_status", data.get("status", 0))
                status_text = "未知"
                if live_status == 1:
                    status_text = "直播中"
                    # 更新全局连接状态为"已连接"
                    try:
                        from app.models.status_monitor_model import StatusMonitorModel, StatusType
                        StatusMonitorModel.instance().update_state(StatusType.CONNECTION, "已连接")
                    except Exception as e:
                        self.logger.error(f"更新全局连接状态失败: {str(e)}")
                elif live_status == 0:
                    status_text = "未开播"
                    # 更新全局连接状态为"未连接"
                    try:
                        from app.models.status_monitor_model import StatusMonitorModel, StatusType
                        StatusMonitorModel.instance().update_state(StatusType.CONNECTION, "未连接")
                        self.logger.info("视频号直播结束，已更新全局连接状态为'未连接'")
                    except Exception as e:
                        self.logger.error(f"更新全局连接状态失败: {str(e)}")
                
                # 优先使用online_count，如果不存在则使用view_count
                view_count = data.get("online_count", data.get("view_count", 0))
                self.update_status_display(status_text, view_count)
                
            elif event_type == "events":
                # 处理事件
                for event in data:
                    # 兼容两种事件类型标记: decoded_type 和 event_name
                    event_type = event.get("decoded_type", event.get("event_name", "unknown"))
                    
                    # 获取用户信息 - 兼容两种数据结构
                    if "user" in event and isinstance(event["user"], dict):
                        user_name = event["user"].get("nickname", "未知用户")
                    else:
                        user_name = event.get("nickname", "未知用户")
                    
                    if event_type == "comment":
                        content = event.get("content", "")
                        self.add_log(f"弹幕: {user_name} - {content}")
                    elif event_type == "gift":
                        # 修改礼物显示格式，优先使用content字段
                        content = event.get("content", "")
                        self.add_log(f"礼物: {content}")
                    elif event_type == "join" or event_type == "enter":
                        self.add_log(f"进入: {user_name}")
                    elif event_type == "like":
                        self.add_log(f"点赞: {user_name}")
                    elif event_type == "follow":
                        self.add_log(f"关注: {user_name}")
        except Exception as e:
            self.logger.error(f"处理微信直播事件时发生错误: {str(e)}")
    
    def set_config(self, pinned_enabled=False, pinned_keyword="", pinned_frequency=5, 
                   live_status="未知", viewers=0):
        """
        设置配置
        
        @param pinned_enabled: 是否启用置顶
        @param pinned_keyword: 置顶关键词
        @param pinned_frequency: 置顶频率（分钟）
        @param live_status: 直播状态
        @param viewers: 观众数量
        """
        # 设置控件值
        self.pinned_enabled.setChecked(pinned_enabled)
        self.keyword_input.setText(pinned_keyword)
        self.frequency_spinbox.setValue(pinned_frequency)
        
        # 设置转发地址
        forward_url = self.wx_config.get_prop("forward_url")
        if forward_url:
            self.forward_url_input.setText(forward_url)
        
        # 更新状态显示
        self.update_status_display(live_status, viewers)
        
        # 记录日志
        self.add_log(f"加载视频号配置: 启用置顶={pinned_enabled}, 关键词={pinned_keyword}, "
                    f"频率={pinned_frequency}分钟, 直播状态={live_status}, 观众={viewers}")
        
        # 触发配置更新信号
        self.channel_config_updated.emit("pinned.enabled", pinned_enabled)
        self.channel_config_updated.emit("pinned.keyword", pinned_keyword)
        self.channel_config_updated.emit("pinned.frequency", pinned_frequency)
        self.channel_config_updated.emit("live_status", live_status)
        self.channel_config_updated.emit("viewers", viewers)
    
    @pyqtSlot(str, str, int)
    def _update_log_and_toast(self, log_msg, toast_msg, toast_type):
        """
        更新日志并显示提示消息
        
        @param log_msg: 日志消息
        @param toast_msg: 提示消息
        @param toast_type: 提示类型
        """
        self.add_log(log_msg)
        show_toast(self, toast_msg, 2000, toast_type)
    
    def shutdown(self):
        """
        关闭模块，释放资源
        """
        # 停止自动检测定时器（如果存在）
        if hasattr(self, "status_timer") and not self.status_timer is None and self.status_timer.isActive():
            self.status_timer.stop()
            self.logger.info("已停止自动检测直播状态")
            
        # 关闭监听器（如果有）
        if self.wx_listener and self.wx_listener.is_alive():
            try:
                self.wx_listener.stop()
                self.logger.info("已停止视频号监听器")
            except Exception as e:
                self.logger.error(f"停止视频号监听器失败: {str(e)}") 